home *** CD-ROM | disk | FTP | other *** search
/ Windows Expert / Windows Expert.iso / windownt / awksrc.zip / RE.C < prev    next >
C/C++ Source or Header  |  1993-09-27  |  3KB  |  155 lines
  1. /*
  2.  * re.c - compile regular expressions.
  3.  */
  4.  
  5. /* 
  6.  * Copyright (C) 1991, 1992 the Free Software Foundation, Inc.
  7.  * 
  8.  * This file is part of GAWK, the GNU implementation of the
  9.  * AWK Progamming Language.
  10.  * 
  11.  * GAWK is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  * 
  16.  * GAWK is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  * 
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with GAWK; see the file COPYING.  If not, write to
  23.  * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24.  */
  25.  
  26. #include "awk.h"
  27.  
  28. /* Generate compiled regular expressions */
  29. Regexp *
  30. make_regexp(s, ignorecase, dfa)
  31. NODE *s;
  32. int ignorecase;
  33. int dfa;
  34. {
  35.     Regexp *rp;
  36.     char *err;
  37.  
  38.     emalloc(rp, Regexp *, sizeof(*rp), "make_regexp");
  39.     memset((char *) rp, 0, sizeof(*rp));
  40.     emalloc(rp->pat.buffer, char *, 16, "make_regexp");
  41.     rp->pat.allocated = 16;
  42.     emalloc(rp->pat.fastmap, char *, 256, "make_regexp");
  43.  
  44.     if (ignorecase)
  45.         rp->pat.translate = casetable;
  46.     else
  47.         rp->pat.translate = NULL;
  48.     if ((err = re_compile_pattern(s->stptr, (size_t) s->stlen, &(rp->pat))) != NULL)
  49.         fatal("%s: /%s/", err, s->stptr);
  50.     if (dfa && !ignorecase) {
  51.         regcompile(s->stptr, s->stlen, &(rp->dfareg), 1);
  52.         rp->dfa = 1;
  53.     } else
  54.         rp->dfa = 0;
  55.     free_temp(s);
  56.     return rp;
  57. }
  58.  
  59. int
  60. research(rp, str, start, len, need_start)
  61. Regexp *rp;
  62. register char *str;
  63. int start;
  64. register int len;
  65. int need_start;
  66. {
  67.     char *ret = str;
  68.  
  69.     if (rp->dfa) {
  70.         char save1;
  71.         char save2;
  72.         int count = 0;
  73.         int try_backref;
  74.  
  75.         save1 = str[start+len];
  76.         str[start+len] = '\n';
  77.         save2 = str[start+len+1];
  78.         ret = regexecute(&(rp->dfareg), str+start, str+start+len+1, 1,
  79.                     &count, &try_backref);
  80.         str[start+len] = save1;
  81.         str[start+len+1] = save2;
  82.     }
  83.     if (ret) {
  84.         if (need_start || rp->dfa == 0)
  85.             return re_search(&(rp->pat), str, start+len, start,
  86.                     len, &(rp->regs));
  87.         else
  88.             return 1;
  89.      } else
  90.         return -1;
  91. }
  92.  
  93. void
  94. refree(rp)
  95. Regexp *rp;
  96. {
  97.     free(rp->pat.buffer);
  98.     free(rp->pat.fastmap);
  99.     if (rp->dfa)
  100.         reg_free(&(rp->dfareg));
  101.     free(rp);
  102. }
  103.  
  104. void
  105. reg_error(s)
  106. const char *s;
  107. {
  108.     fatal(s);
  109. }
  110.  
  111. Regexp *
  112. re_update(t)
  113. NODE *t;
  114. {
  115.     NODE *t1;
  116.  
  117. #    define    CASE    1
  118.     if ((t->re_flags & CASE) == IGNORECASE) {
  119.         if (t->re_flags & GCONST)
  120.             return t->re_reg;
  121.         t1 = force_string(tree_eval(t->re_exp));
  122.         if (t->re_text) {
  123.             if (cmp_nodes(t->re_text, t1) == 0) {
  124.                 free_temp(t1);
  125.                 return t->re_reg;
  126.             }
  127.             unref(t->re_text);
  128.         }
  129.         t->re_text = dupnode(t1);
  130.         free_temp(t1);
  131.     }
  132.     if (t->re_reg)
  133.         refree(t->re_reg);
  134.     if (t->re_cnt)
  135.         t->re_cnt++;
  136.     if (t->re_cnt > 10)
  137.         t->re_cnt = 0;
  138.     if (!t->re_text) {
  139.         t1 = force_string(tree_eval(t->re_exp));
  140.         t->re_text = dupnode(t1);
  141.         free_temp(t1);
  142.     }
  143.     t->re_reg = make_regexp(t->re_text, IGNORECASE, t->re_cnt);
  144.     t->re_flags &= ~CASE;
  145.     t->re_flags |= IGNORECASE;
  146.     return t->re_reg;
  147. }
  148.  
  149. void
  150. resetup()
  151. {
  152.     (void) re_set_syntax(RE_SYNTAX_AWK);
  153.     regsyntax(RE_SYNTAX_AWK, 0);
  154. }
  155.